import { Card, CardPattern } from '../types/card'
import { GameConfig, Player } from '../types/game'
import { identifyCardPattern } from './gameLogic'

/**
 * 游戏配置验证错误类型
 */
export class ValidationError extends Error {
  constructor(message: string, public field?: string) {
    super(message)
    this.name = 'ValidationError'
  }
}

/**
 * 验证游戏配置
 */
export function validateGameConfig(config: GameConfig): boolean {
  try {
    // 验证AI手牌
    if (!config.aiCards || config.aiCards.length === 0) {
      throw new ValidationError('AI手牌不能为空', 'aiCards')
    }

    if (config.aiCards.length > 54) {
      throw new ValidationError('AI手牌数量不能超过54张', 'aiCards')
    }

    // 验证首次出牌玩家座位号
    if (config.firstPlayer < 0 || config.firstPlayer > 3) {
      throw new ValidationError('首次出牌玩家座位号必须在0-3之间', 'firstPlayer')
    }

    // 验证级牌 (可以为空)
    if (config.trumpCard && !isValidCard(config.trumpCard)) {
      throw new ValidationError('级牌格式不正确', 'trumpCard')
    }

    return true
  } catch (error) {
    if (error instanceof ValidationError) {
      throw error
    }
    throw new ValidationError('游戏配置验证失败')
  }
}

/**
 * 验证扑克牌是否有效
 */
export function isValidCard(card: Card): boolean {
  const id = card.id

  // 第一副牌的ID范围
  const firstDeckRanges = [
    [256, 268],   // 方块 2-A
    [512, 524],   // 梅花 2-A
    [768, 780],   // 红桃 2-A
    [1024, 1036], // 黑桃 2-A
  ]

  // 第二副牌的ID范围 (第一副+10000)
  const secondDeckRanges = [
    [10256, 10268],   // 方块 2-A
    [10512, 10524],   // 梅花 2-A
    [10768, 10780],   // 红桃 2-A
    [11024, 11036],   // 黑桃 2-A
  ]

  // 使用公式生成的第二副牌ID范围 (suit<<8)+rank+10000
  const formulaBasedRanges = [
    [10000, 10012],   // 方块 2-A
    [10256, 10268],   // 梅花 2-A
    [10512, 10524],   // 红桃 2-A
    [10768, 10780],   // 黑桃 2-A
  ]

  // 大小王
  const jokerIds = [1037, 1294, 11037, 11294]

  // 检查是否是大小王
  if (jokerIds.includes(id)) {
    return true
  }

  // 检查第一副牌
  for (const [min, max] of firstDeckRanges) {
    if (id >= min && id <= max) {
      return true
    }
  }

  // 检查第二副牌
  for (const [min, max] of secondDeckRanges) {
    if (id >= min && id <= max) {
      return true
    }
  }

  // 检查使用公式生成的第二副牌
  for (const [min, max] of formulaBasedRanges) {
    if (id >= min && id <= max) {
      return true
    }
  }

  console.error('无效的卡牌ID:', id, '卡牌对象:', card)
  return false
}

/**
 * 验证扑克牌数组
 */
export function validateCards(cards: Card[]): boolean {
  if (!Array.isArray(cards)) {
    throw new ValidationError('牌必须是数组格式')
  }

  // 检查每张牌的有效性
  for (const card of cards) {
    console.log('validateCards - 验证卡牌:', {
      id: card.id,
      suit: card.suit,
      rank: card.rank,
      display: card.display,
      '完整对象': card
    })

    if (!isValidCard(card)) {
      console.error('validateCards - 发现无效卡牌:', {
        id: card.id,
        suit: card.suit,
        rank: card.rank,
        display: card.display,
        '完整对象': card
      })
      throw new ValidationError(`无效的扑克牌: ${card.id}`)
    }
  }

  // 检查是否有重复的牌
  const cardIds = cards.map(card => card.id)
  const uniqueIds = new Set(cardIds)
  if (cardIds.length !== uniqueIds.size) {
    throw new ValidationError('不能包含重复的扑克牌')
  }

  // 掼蛋规则：除了炸弹，最多只能出6张牌
  if (cards.length > 6) {
    // 检查是否所有牌面值相同（炸弹）
    const firstRank = cards[0].rank
    const isAllSameRank = cards.every(card => card.rank === firstRank)

    if (!isAllSameRank) {
      throw new ValidationError('除了炸弹，最多只能出6张牌')
    }
  }

  return true
}

/**
 * 验证出牌组合
 */
export function validateCardCombination(cards: Card[], levelCard?: Card | null): boolean {
  try {
    validateCards(cards)

    if (cards.length === 0) {
      return true // 过牌是合法的
    }

    const combination = identifyCardPattern(cards, levelCard)

    // 检查是否为有效牌型
    if (combination.type === CardPattern.PASS && cards.length > 0) {
      throw new ValidationError('无效的牌型组合')
    }

    return true
  } catch (error) {
    if (error instanceof ValidationError) {
      throw error
    }
    throw new ValidationError('牌型组合验证失败')
  }
}

/**
 * 验证玩家数据
 */
export function validatePlayer(player: Player): boolean {
  if (!player.name || player.name.trim() === '') {
    throw new ValidationError('玩家名称不能为空', 'name')
  }

  if (player.id < 0 || player.id > 3) {
    throw new ValidationError('玩家ID必须在0-3之间', 'id')
  }

  if (player.handCards) {
    validateCards(player.handCards)
  }

  if (player.currentPlay) {
    validateCards(player.currentPlay)
  }

  return true
}

/**
 * 验证玩家出牌
 */
export function validatePlayerPlay(
  playerId: number,
  cards: Card[],
  playerHandCards: Card[],
  isAIPlayer: boolean = false,
  levelCard?: Card | null
): boolean {
  // 验证玩家ID
  if (playerId < 0 || playerId > 3) {
    throw new ValidationError('无效的玩家ID')
  }

  // 验证出牌
  validateCardCombination(cards, levelCard)

  // 只对AI玩家检查是否拥有这些牌
  if (isAIPlayer) {
    for (const card of cards) {
      const hasCard = playerHandCards.some(handCard => handCard.id === card.id)
      if (!hasCard) {
        throw new ValidationError(`AI玩家没有这张牌: ${card.display}`)
      }
    }
  }

  return true
}

/**
 * 验证座位号
 */
export function validateSeatId(seatId: number): boolean {
  if (!Number.isInteger(seatId) || seatId < 0 || seatId > 3) {
    throw new ValidationError('座位号必须是0-3之间的整数')
  }
  return true
}

/**
 * 验证牌型代码
 */
export function validatePatternType(patternType: number): boolean {
  const validPatterns = Object.values(CardPattern).filter(v => typeof v === 'number')
  if (!validPatterns.includes(patternType)) {
    throw new ValidationError(`无效的牌型代码: ${patternType}`)
  }
  return true
}

/**
 * 验证API请求数据
 */
export function validateAPIRequest(data: any): boolean {
  if (!data || typeof data !== 'object') {
    throw new ValidationError('请求数据格式错误')
  }

  if (!data.gameState || typeof data.gameState !== 'object') {
    throw new ValidationError('游戏状态数据缺失')
  }

  if (!Array.isArray(data.aiCards)) {
    throw new ValidationError('AI手牌数据格式错误')
  }

  return true
}